Programmable logic integrated circuits (ICs) are a type of programmable integrated circuit (IC) having circuitry that may be programmed or configured by a user to perform specified logic functions. There are different types of programmable logic ICs, such as programmable logic arrays (PLAs) and complex programmable logic devices (CPLDs). One type of programmable logic IC, known as a field programmable gate array (FPGA), is very popular because of a superior combination of capacity, flexibility, time-to-market, and cost.
An FPGA typically includes an array of configurable logic blocks (CLBs) and programmable input/output blocks (IOBs). The CLBs and IOBs are interconnected by a programmable interconnect structure. The CLBs, IOBs, and interconnect structure are typically programmed by loading a stream of configuration data (known as a bitstream) into internal configuration memory cells that define how the CLBs, IOBs, and interconnect structure are configured. An FPGA may also include various dedicated logic circuits, such as memories, microprocessors, digital clock managers (DCMs), and input/output (I/O) transceivers.
Some programmable ICs are configured to support dynamic reconfiguration. That is, some programmable ICs have the ability to reprogram a portion of the programmable logic while the rest of the programmable logic continues to operate according to the configured logic functions. In creating a system that supports dynamic partial reconfiguration, the designer will particularly architect the design to allow for dynamic partial reconfiguration. That is, the designer will specify modules that may be dynamically replaced. In addition, the designer must specify suitable interfaces that support the dynamic partial reconfiguration. Since a portion of the device may be reconfigured while the device is active, predefined macros or other entities are used to interface to the reconfigurable modules. One such instantiation of this implementation uses three-state buffer (tbuf) macros (also referred to as bus macros) as the interfaces of the reconfigurable modules. During reconfiguration, the tbuf macros allow a given module to be isolated from the portion of the design that is not being reconfigured. U.S. Pat. No. 7,669,163 describes an example implementation that uses tbuf macros.
Though tools exist to design and implement applications that support dynamic partial reconfiguration, there are few tools that provide support for user-level management of dynamic partial reconfiguration of the application while the application is running. For example, if an end-user or someone other than the designer wants to initiate dynamic partial reconfiguration of an application, the options available to the end-user may be limited to those contemplated by the designer when the application was implemented. Alternatively, if the end-user has enough of the original design information, the proper design tools, and the requisite skills, the end-user may create the desired modules to be used in the dynamic partial reconfiguration. Neither alternative may be viable in many instances.
A method and system that addresses these and other issues is therefore desirable.